// --------------------------------------------------------------------------------------------------------------------
// <copyright file="DriveHeartbeatTest.cs" company="Microsoft Corporation">
// The MIT License (MIT)
// 
// Copyright (c) 2014, Microsoft Corporation
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
//  of this software and associated documentation files (the "Software"), to deal
//  in the Software without restriction, including without limitation the rights
//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//  copies of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
//  all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//  THE SOFTWARE.
// </copyright>
// --------------------------------------------------------------------------------------------------------------------
namespace Microsoft.Robotics.Hardware.EV4.UnitTests
{
    using System;
    using Microsoft.Robotics.Hardware.DAC;
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    /// <summary>
    /// Tests DriveHeartbeat
    /// </summary>
    [TestClass]
    public class DriveHeartbeatTest
    {
        /// <summary>
        /// Test TimeStamp property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TimeStampPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TimeStamp = 123;
            Assert.AreEqual<long>(123, heartbeat.TimeStamp);
        }

        /// <summary>
        /// Test Prox1InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox1InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox1InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox1InMm);
        }

        /// <summary>
        /// Test Prox2InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox2InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox2InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox2InMm);
        }

        /// <summary>
        /// Test Prox3InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox3InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox3InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox3InMm);
        }

        /// <summary>
        /// Test Prox4InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox4InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox4InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox4InMm);
        }

        /// <summary>
        /// Test Prox5InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox5InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox5InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox5InMm);
        }

        /// <summary>
        /// Test Prox6InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox6InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox6InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox6InMm);
        }

        /// <summary>
        /// Test Prox7InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox7InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox7InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox7InMm);
        }

        /// <summary>
        /// Test Prox8InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Prox8InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Prox8InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Prox8InMm);
        }

        /// <summary>
        /// Test Cliff1InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Cliff1InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Cliff1InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Cliff1InMm);
        }

        /// <summary>
        /// Test Cliff2InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Cliff2InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Cliff2InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Cliff2InMm);
        }

        /// <summary>
        /// Test Cliff3InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Cliff3InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Cliff3InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Cliff3InMm);
        }

        /// <summary>
        /// Test Cliff4InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Cliff4InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Cliff4InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Cliff4InMm);
        }

        /// <summary>
        /// Test Cliff5InMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Cliff5InMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Cliff5InMm = 123;
            Assert.AreEqual<int>(123, heartbeat.Cliff5InMm);
        }

        /// <summary>
        /// Test CarryDetected property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4CarryDetectedPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.CarryDetected = 123;
            Assert.AreEqual<byte>(123, heartbeat.CarryDetected);
        }

        /// <summary>
        /// Test TemperatureInternalIn10ThsCelsius property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TemperatureInternalIn10ThsCelsiusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TemperatureInternalIn10ThsCelsius = 123;
            Assert.AreEqual<short>(123, heartbeat.TemperatureInternalIn10ThsCelsius);
        }

        /// <summary>
        /// Test TemperatureProjectorRedInCelsius property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TemperatureProjectorRedInCelsiusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TemperatureProjectorRedInCelsius = 123;
            Assert.AreEqual<short>(123, heartbeat.TemperatureProjectorRedInCelsius);
        }

        /// <summary>
        /// Test TemperatureProjectorGreenInCelsius property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TemperatureProjectorGreenInCelsiusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TemperatureProjectorGreenInCelsius = 123;
            Assert.AreEqual<short>(123, heartbeat.TemperatureProjectorGreenInCelsius);
        }

        /// <summary>
        /// Test TemperatureProjectorBlueInCelsius property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TemperatureProjectorBlueInCelsiusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TemperatureProjectorBlueInCelsius = 123;
            Assert.AreEqual<short>(123, heartbeat.TemperatureProjectorBlueInCelsius);
        }

        /// <summary>
        /// Test ProjectorIsBusy property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ProjectorIsBusyPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ProjectorIsBusy = 123;
            Assert.AreEqual<byte>(123, heartbeat.ProjectorIsBusy);
        }

        /// <summary>
        /// Test TemperatureExternalIn10ThsCelsius property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TemperatureExternalIn10ThsCelsiusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TemperatureExternalIn10ThsCelsius = 123;
            Assert.AreEqual<short>(123, heartbeat.TemperatureExternalIn10ThsCelsius);
        }

        /// <summary>
        /// Test RelativeHumidityInPercent property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4RelativeHumidityInPercentPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.RelativeHumidityInPercent = 123;
            Assert.AreEqual<int>(123, heartbeat.RelativeHumidityInPercent);
        }

        /// <summary>
        /// Test BatteryVoltage property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4BatteryVoltageInmVPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.BatteryVoltageInmV = 123;
            Assert.AreEqual<int>(123, heartbeat.BatteryVoltageInmV);
        }

        /// <summary>
        /// Test BatteryCurrent property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4BatteryCurrentInmAPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.BatteryCurrentInmA = 123;
            Assert.AreEqual<short>(123, heartbeat.BatteryCurrentInmA);
        }

        /// <summary>
        /// Test BatteryTemperatureIn10ThsCelsius property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4BatteryTemperatureIn10ThsCelsiusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.BatteryTemperatureIn10ThsCelcius = 123;
            Assert.AreEqual<short>(123, heartbeat.BatteryTemperatureIn10ThsCelcius);
        }

        /// <summary>
        /// Test BatteryChargeInPercent property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4BatteryChargeInPercentPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.BatteryChargeInPercent = 123;
            Assert.AreEqual<short>(123, heartbeat.BatteryChargeInPercent);
        }

        /// <summary>
        /// Test BatteryAverageTimeToEmptyInMinutes property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4BatteryAvgTimeToEmptyInMinutesPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.BatteryAvgTimeToEmptyInMinutes = 123;
            Assert.AreEqual<short>(123, heartbeat.BatteryAvgTimeToEmptyInMinutes);
        }

        /// <summary>
        /// Test BatteryStatus property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4BatteryStatusPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.BatteryStatus = 123;
            Assert.AreEqual<int>(123, heartbeat.BatteryStatus);
        }

        /// <summary>
        /// Test Power5V property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Power5VInmVPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Power5VInmV = 123;
            Assert.AreEqual<int>(123, heartbeat.Power5VInmV);
        }

        /// <summary>
        /// Test Power12VI property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4Power12VInmVPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.Power12VInmV = 123;
            Assert.AreEqual<int>(123, heartbeat.Power12VInmV);
        }

        /// <summary>
        /// Test AccelerationForward property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4AccelForwardInGPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.AccelForwardInG = 123;
            Assert.AreEqual<float>(123, heartbeat.AccelForwardInG);
        }

        /// <summary>
        /// Test AccelerationRight property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4AccelRightInGPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.AccelRightInG = 123;
            Assert.AreEqual<float>(123, heartbeat.AccelRightInG);
        }

        /// <summary>
        /// Test AccelerationUp property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4AccelUpInGPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.AccelUpInG = 123;
            Assert.AreEqual<float>(123, heartbeat.AccelUpInG);
        }

        /// <summary>
        /// Test GyroForwardInRadiansPerSecond property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4GyroForwardInRadiansPerSecondPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.GyroForwardInRadiansPerSecond = 123;
            Assert.AreEqual<float>(123, heartbeat.GyroForwardInRadiansPerSecond);
        }

        /// <summary>
        /// Test GyroRightInRadiansPerSecond property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4GyroRightInRadiansPerSecondPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.GyroRightInRadiansPerSecond = 123;
            Assert.AreEqual<float>(123, heartbeat.GyroRightInRadiansPerSecond);
        }

        /// <summary>
        /// Test GyroUpInRadiansPerSecond property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4GyroUpInRadiansPerSecondPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.GyroUpInRadiansPerSecond = 123;
            Assert.AreEqual<float>(123, heartbeat.GyroUpInRadiansPerSecond);
        }

        /// <summary>
        /// Test MotorLeftPositionInMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4MotorLeftPositionInMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.MotorLeftPositionInMm = 123;
            Assert.AreEqual<int>(123, heartbeat.MotorLeftPositionInMm);
        }

        /// <summary>
        /// Test MotorRightPositionInMm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4MotorRightPositionInMmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.MotorRightPositionInMm = 123;
            Assert.AreEqual<int>(123, heartbeat.MotorRightPositionInMm);
        }

        /// <summary>
        /// Test MotorLeftVelocityInMperSec property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4MotorLeftVelocityInMperSecPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.MotorLeftVelocityInMperSec = 123;
            Assert.AreEqual<float>(123, heartbeat.MotorLeftVelocityInMperSec);
        }

        /// <summary>
        /// Test MotorRightVelocityInMperSec property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4MotorRightVelocityInMperSecPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.MotorRightVelocityInMperSec = 123;
            Assert.AreEqual<float>(123, heartbeat.MotorRightVelocityInMperSec);
        }

        /// <summary>
        /// Test MotorLeftAccelerationInMperSec2 property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4MotorLeftAccelerationInMperSec2PropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.MotorLeftAccelerationInMperSec2 = 123;
            Assert.AreEqual<float>(123, heartbeat.MotorLeftAccelerationInMperSec2);
        }

        /// <summary>
        /// Test MotorRightAccelerationInMperSec2 property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4MotorRightAccelerationInMperSec2PropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.MotorRightAccelerationInMperSec2 = 123;
            Assert.AreEqual<float>(123, heartbeat.MotorRightAccelerationInMperSec2);
        }

        /// <summary>
        /// Test PowerStates property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4PowerStatesPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.PowerStates = PowerStates.EnableDepthCam;
            Assert.AreEqual<PowerStates>(PowerStates.EnableDepthCam, heartbeat.PowerStates);
        }

        /// <summary>
        /// Test SensorStates property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4SensorStatesPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.SensorStates = DriveSensorStates.BatteryCharging;
            Assert.AreEqual<DriveSensorStates>(DriveSensorStates.BatteryCharging, heartbeat.SensorStates);
        }

        /// <summary>
        /// Test ProjectorHeadingInRadians property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ProjectorHeadingInRadiansPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ProjectorHeadingInRadians = 123;
            Assert.AreEqual<float>(123, heartbeat.ProjectorHeadingInRadians);
        }

        /// <summary>
        /// Test ProjectorInversion property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ProjectorInversionPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ProjectorInversion = 123;
            Assert.AreEqual<byte>(123, heartbeat.ProjectorInversion);
        }

        /// <summary>
        /// Test ProjectorBrightness property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ProjectorBrightnessPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ProjectorBrightness = 123;
            Assert.AreEqual<int>(123, heartbeat.ProjectorBrightness);
        }

        /// <summary>
        /// Test ProjectorFocusPositionInSteps property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ProjectorFocusPositionInStepsPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ProjectorFocusPositionInSteps = 123;
            Assert.AreEqual<short>(123, heartbeat.ProjectorFocusPositionInSteps);
        }

        /// <summary>
        /// Test ProjectorIdle property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ProjectorIdlePropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ProjectorIdle = 123;
            Assert.AreEqual<byte>(123, heartbeat.ProjectorIdle);
        }

        /// <summary>
        /// Test CameraHeadingInRadians property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4CameraHeadingInRadiansPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.CameraHeadingInRadians = 123;
            Assert.AreEqual<float>(123, heartbeat.CameraHeadingInRadians);
        }

        /// <summary>
        /// Test TurretHeadingInRadians property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TurretHeadingInRadiansPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TurretHeadingInRadians = 123;
            Assert.AreEqual<float>(123, heartbeat.TurretHeadingInRadians);
        }

        /// <summary>
        /// Test TurretVelocity property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TurretVelocityInMiliRadsPerSecPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TurretVelocityInMiliRadsPerSec = 123;
            Assert.AreEqual<float>(123, heartbeat.TurretVelocityInMiliRadsPerSec);
        }

        /// <summary>
        /// Test SonarDistanceLeftInMillimeters property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4SonarDistanceLeftInMillimetersPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.SonarDistanceLeftInMillimeters = 123;
            Assert.AreEqual<int>(123, heartbeat.SonarDistanceLeftInMillimeters);
        }

        /// <summary>
        /// Test SonarDistanceRightInMillimeters property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4SonarDistanceRightInMillimetersPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.SonarDistanceRightInMillimeters = 123;
            Assert.AreEqual<int>(123, heartbeat.SonarDistanceRightInMillimeters);
        }

        /// <summary>
        /// Test LeftFanPower0To1 property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4LeftFanPower0To1PropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.LeftFanPower0To1 = 123;
            Assert.AreEqual<float>(123, heartbeat.LeftFanPower0To1);
        }

        /// <summary>
        /// Test RightFanPower0To1 property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4RightFanPower0To1PropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.RightFanPower0To1 = 123;
            Assert.AreEqual<float>(123, heartbeat.RightFanPower0To1);
        }

        /// <summary>
        /// Test LeftFanRpm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4LeftFanRpmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.LeftFanRpm = 123;
            Assert.AreEqual<int>(123, heartbeat.LeftFanRpm);
        }

        /// <summary>
        /// Test RightFanRpm property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4RightFanRpmPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.RightFanRpm = 123;
            Assert.AreEqual<int>(123, heartbeat.RightFanRpm);
        }

        /// <summary>
        /// Test CliffState property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4CliffStatePropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.CliffState = CliffSensorStates.CenterFrontCliffSensor;
            Assert.AreEqual<CliffSensorStates>(CliffSensorStates.CenterFrontCliffSensor, heartbeat.CliffState);
        }

        /// <summary>
        /// Test ServoStates property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4ServoStatesPropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.ServoStates = 123;
            Assert.AreEqual<int>(123, heartbeat.ServoStates);
        }

        /// <summary>
        /// Test LeftWheelReadyForNextSequence property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4LeftWheelReadyForNextSequencePropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.LeftWheelReadyForNextSequence = 123;
            Assert.AreEqual<byte>(123, heartbeat.LeftWheelReadyForNextSequence);
        }

        /// <summary>
        /// Test RightWheelReadyForNextSequence property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4RightWheelReadyForNextSequencePropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.RightWheelReadyForNextSequence = 123;
            Assert.AreEqual<byte>(123, heartbeat.RightWheelReadyForNextSequence);
        }

        /// <summary>
        /// Test TurretReadyForNextSequence property.
        /// </summary>
        [Priority(0)]
        [TestMethod]
        [TestCategory("Unit")]
        public void Ev4TurretReadyForNextSequencePropertyTest()
        {
            var heartbeat = new DriveHeartbeat();
            heartbeat.TurretReadyForNextSequence = 123;
            Assert.AreEqual<byte>(123, heartbeat.TurretReadyForNextSequence);
        }
    }
}
